home *** CD-ROM | disk | FTP | other *** search
/ Software Explosion / Software Explosion (Fore-Matt Home Computing)(1996).iso / games / workbench / five_in_a_line / source / logic.c < prev    next >
C/C++ Source or Header  |  1994-04-23  |  8KB  |  351 lines
  1. #include <exec/exec.h>
  2. #include <proto/exec.h>
  3.  
  4. #include <intuition/intuition.h>
  5. #include <proto/intuition.h>
  6.  
  7. #include <proto/graphics.h>
  8.  
  9. #include <libraries/reqtools.h>
  10. #include <proto/reqtools.h>
  11.  
  12. #include <libraries/gadtools.h>
  13. #include <proto/gadtools.h>
  14.  
  15. #include <math.h>
  16.  
  17. #include "fil.h"
  18.  
  19. extern    APTR            VisualInfo;
  20. extern struct Screen    *Scr;
  21. extern struct Window    *mwWnd;
  22. extern BOOL                startplayer;
  23. extern UBYTE            currentplayer;
  24. extern UWORD            offx;
  25. extern UWORD            offy;
  26. extern int                boardsize;
  27.  
  28. #define AttackFactor    4
  29.  
  30. static WORD Weight[] = { 0, 0, 4, 20, 100, 500, 0 };
  31. UBYTE Board [ MAXBOARDSIZE + 1 ] [ MAXBOARDSIZE + 1 ];
  32. UBYTE Aline [ 4 ] [ MAXBOARDSIZE + 1 ] [ MAXBOARDSIZE + 1 ] [ 2 ];
  33. int   Value [ MAXBOARDSIZE + 1 ] [ MAXBOARDSIZE + 1 ] [ 2 ];
  34.  
  35. void drawboard ( void )
  36. {
  37.     int    row;
  38.     int    col;
  39.  
  40.     for ( row = 0; row < boardsize; row ++ )
  41.     {
  42.         for ( col = 0; col < boardsize; col ++ )
  43.         {
  44.             DrawBevelBox ( mwWnd->RPort, offx + INTERWIDTH + ( row * BOXSIZE ),
  45.                 offy + INTERHEIGHT + ( col * BOXSIZE ), BOXSIZE, BOXSIZE, 
  46.                 GT_VisualInfo, VisualInfo, TAG_DONE );
  47.         }
  48.     }
  49.  
  50. }
  51.  
  52. int initnewgame ( void )
  53. {
  54.     int     playerno;
  55.     int     depth;
  56.     int     row;
  57.     int     col;
  58.  
  59.     if ( startplayer ) {
  60.         startplayer = FALSE;
  61.         if ( currentplayer == NULL ) currentplayer = HUMAN;
  62.     }
  63.     else {
  64.         startplayer = TRUE;
  65.         if ( currentplayer == NULL ) currentplayer = AMIGA;
  66.     }
  67.  
  68.     for ( row = 1; row <= boardsize; row ++ ) {
  69.         for ( col = 1; col <= boardsize; col ++ )
  70.             Board [ row ] [ col ] = EMPTY;
  71.     }
  72.  
  73.     for ( depth = 0; depth <= 3; depth ++ ) {
  74.         for ( row = 1; row <= boardsize; row ++ ) {
  75.             for ( col = 1; col <= boardsize; col ++ ) {
  76.                 for ( playerno = 0; playerno <= 1; playerno ++ )
  77.                     Aline [ depth ] [ row ] [ col ] [ playerno ] = 0;
  78.             }
  79.         }
  80.     }
  81.  
  82.     for ( row = 1; row <= boardsize; row ++ ) {
  83.         for ( col = 1; col <= boardsize; col ++ ) {
  84.             for ( playerno = 0; playerno <= 1; playerno ++ )
  85.                 Value [ row ] [  col ] [ playerno ] = 0;
  86.         }
  87.     }
  88.  
  89.     EraseRect ( mwWnd->RPort, offx + INTERWIDTH, offy + INTERHEIGHT,
  90.                               offx + INTERWIDTH + boardsize * BOXSIZE,
  91.                               offy + INTERHEIGHT + boardsize * BOXSIZE);
  92.     drawboard ();
  93.     return ( TRUE );
  94. }
  95.  
  96. void Addup ( int row, int col, int depth, BOOL *gamewon )
  97. {
  98.     int player;
  99.  
  100.     if ( currentplayer == AMIGA ) player = 1;
  101.     else player = 0;
  102.  
  103.     if ( ++ Aline [ depth ] [ row ] [ col ] [ player ] == 5) *gamewon = TRUE;
  104. }
  105.  
  106.  
  107. void UpdateValue ( int row, int col, int x1, int y1, int dir, int j )
  108.  
  109. {
  110.     int x;
  111.     int y;
  112.     int player;
  113.     int opponent;
  114.  
  115.     if ( currentplayer == AMIGA ) {
  116.         player = 1;
  117.         opponent = 0;
  118.     }
  119.     else {
  120.         player = 0;
  121.         opponent = 1;
  122.     }
  123.  
  124.     switch ( dir ) {
  125.         case 0:
  126.             x = j;
  127.             y = 0;
  128.             break;
  129.  
  130.         case 1:
  131.             x = j;
  132.             y = j;
  133.             break;
  134.  
  135.         case 2:
  136.             x = 0;
  137.             y = j;
  138.             break;
  139.  
  140.         case 3:
  141.             x = - j;
  142.             y = j;
  143.             break;
  144.     }
  145.  
  146.     if ( Aline [ dir ] [ x1 ] [ y1 ] [ opponent ] == 0)
  147.         Value [ x1 + x ] [ y1 + y ] [ player ] = 
  148.             Value [ x1 + x ] [ y1 + y ] [ player ] + 
  149.             Weight [ Aline [ dir ] [ x1 ] [ y1 ] [ player ] + 1 ] - 
  150.             Weight [ Aline [ dir ] [ x1 ] [ y1 ] [ player ] ];
  151.     else if ( Aline [ dir ] [ x1 ] [ y1 ] [ player ] == 1)
  152.             Value [ x1 + x ] [ y1 + y ] [ opponent ] =
  153.                 Value [ x1 + x ] [ y1 + y ] [ opponent ] - 
  154.                 Weight [ Aline [ dir ] [ x1 ] [ y1 ] [ opponent ] + 1 ];
  155. }
  156.  
  157. void findmove ( int *x, int *y , FLOAT playlevel )
  158.  
  159. {
  160.     int maxvalue = -1;
  161.     int row;
  162.     int col;
  163.     int player;
  164.     int opponent;
  165.     int value;
  166.  
  167.     if ( currentplayer == AMIGA ) {
  168.         player = 1;
  169.         opponent = 0;
  170.     }
  171.     else {
  172.         player = 0;
  173.         opponent = 1;
  174.     }
  175.  
  176.     *x = ( boardsize + 1 ) / 2;
  177.     *y = ( boardsize + 1 ) / 2;
  178.  
  179.     if ( Board [ *x ] [ *y ] == EMPTY ) maxvalue = 4;
  180.  
  181.     for ( row = 1; row <= boardsize; row ++ ) {
  182.         for ( col = 1; col <= boardsize; col ++ ) {
  183.             if ( Board [ row ] [ col ] == EMPTY ) {
  184.                 value = Value [ row ] [ col ] [ player ] * 
  185.                     ( 16 + AttackFactor ) / 16 + Value [ row ] [ col ] [ opponent ];
  186.                 if ( value > maxvalue ) {
  187.                     if ( drand48() >= playlevel ) {
  188.                         *x = row;
  189.                         *y = col;
  190.                         maxvalue = value;
  191.                     }
  192.                 }
  193.             }
  194.         }
  195.     }
  196. }
  197.  
  198. int checkdrawgame ( void )
  199. {
  200.     BOOL     drawgame = TRUE;
  201.     int        row;
  202.     int        startrow;
  203.     int        col;
  204.     int        startcol;
  205.     UBYTE    player;
  206.     int        inline;
  207.  
  208.     for ( player = HUMAN; player <= AMIGA; player ++ ) {
  209.         /* check horizontal */
  210.  
  211.         for ( row = 1; row <= boardsize; row ++ ) {
  212.             inline = 0;
  213.             for ( col = 1; col <= boardsize; col ++ ) {
  214.                 if ( Board [ row ] [ col ] == player || Board [ row ] [ col ] == EMPTY ) {
  215.                     inline ++;
  216.                     if ( inline == 5 ) {
  217.                         drawgame = FALSE;
  218.                         col = boardsize;
  219.                         row = boardsize;
  220.                         player = AMIGA + 1;
  221.                     }
  222.                 }
  223.                 else inline = 0;
  224.             }
  225.         }
  226.  
  227.         /* check vertical */
  228.  
  229.         if ( drawgame == TRUE ) {
  230.             for ( col = 1; col <= boardsize; col ++ ) {
  231.                 inline = 0;
  232.                 for ( row = 1; row <= boardsize; row ++ ) {
  233.                     if ( Board [ row ] [ col ] == player || Board [ row ] [ col ] == EMPTY ) {
  234.                         inline ++;
  235.                         if ( inline == 5 ) {
  236.                             drawgame = FALSE;
  237.                             col = boardsize;
  238.                             row = boardsize;
  239.                             player = AMIGA + 1;
  240.                         }
  241.                     }
  242.                     else inline = 0;
  243.                 }
  244.             }
  245.         }
  246.  
  247.         /* check diagonal 1  */
  248.  
  249.         if ( drawgame == TRUE ) {
  250.             for ( col = 1; col <= boardsize - 4; col ++ ) { 
  251.                 inline = 0;
  252.                 startrow = col + 5;
  253.                 if ( startrow > boardsize ) startrow = boardsize;
  254.                 for ( row = startrow; row >= 1; row -- ) {
  255.                     if ( Board [ row ] [ col ] == player || Board [ row ] [ col ] == EMPTY ) {
  256.                         inline ++;
  257.                         if ( inline == 5 ) {
  258.                             drawgame = FALSE;
  259.                             col = boardsize;
  260.                             row = 0;
  261.                             player = AMIGA + 1;
  262.                         }
  263.                     }
  264.                     else inline = 0;
  265.                 }
  266.             }
  267.         }
  268.  
  269.         /* check diagonal 2  */
  270.  
  271.         if ( drawgame == TRUE ) {
  272.             for ( row = 1; row <= boardsize - 4; row ++ ) { 
  273.                 inline = 0;
  274.                 startcol = row + 5;
  275.                 if ( startcol > boardsize ) startcol = boardsize;
  276.                 for ( col = startcol; col >= 1; col -- ) {
  277.                     if ( Board [ row ] [ col ] == player || Board [ row ] [ col ] == EMPTY ) {
  278.                         inline ++;
  279.                         if ( inline == 5 ) {
  280.                             drawgame = FALSE;
  281.                             col = 0;
  282.                             row = boardsize;
  283.                             player = AMIGA + 1;
  284.                         }
  285.                     }
  286.                     else inline = 0;
  287.                 }
  288.             }
  289.         }
  290.     }
  291.  
  292.     if ( drawgame ) {
  293.         showresult ( "It's a draw!!!" );
  294.         return ( FALSE);
  295.     }
  296.     else return ( TRUE );
  297. }
  298.  
  299. void makemove ( int row, int col , BOOL *gamewon )
  300. {
  301.     int dir;
  302.     int i;
  303.     int j;
  304.     int x1;
  305.     int y1;
  306.  
  307.     dir = 0;
  308.     for ( i = 0; i <= 4; i ++ ) {
  309.         x1 = row - i;
  310.         y1 = col;
  311.         if ( x1 >= 1 && x1 <= boardsize - 4 ) {
  312.             Addup ( x1, y1, dir, gamewon );
  313.             for ( j = 0; j <= 4; j ++ )
  314.                 UpdateValue ( row, col, x1, y1, dir, j );
  315.         }
  316.     }
  317.  
  318.     dir = 1 ;
  319.     for ( i = 0; i <= 4; i ++ ) {
  320.         x1 = row - i;
  321.         y1 = col - i;
  322.         if ( ( x1 >= 1 && x1 <= boardsize - 4 ) && ( y1 >= 1 && y1 <= boardsize - 4 ) ) {
  323.             Addup ( x1, y1, dir, gamewon );
  324.             for ( j = 0; j <= 4; j ++ )
  325.                 UpdateValue ( row, col, x1, y1, dir, j );
  326.         }
  327.     }
  328.  
  329.     dir = 3;
  330.     for ( i = 0; i <= 4; i ++ ) {
  331.         x1 = row + i;
  332.         y1 = col - i;
  333.         if ( ( x1 >= 5 && x1 <= boardsize ) && ( y1 >= 1 && y1 <= boardsize - 4 ) ) {
  334.             Addup ( x1, y1, dir, gamewon );
  335.             for ( j = 0; j <= 4; j ++ )
  336.                 UpdateValue ( row, col, x1, y1, dir, j );
  337.         }
  338.     }
  339.  
  340.     dir = 2;
  341.     for ( i = 0; i <= 4; i ++ ) {
  342.         x1 = row;
  343.         y1 = col - i;
  344.         if ( y1 >= 1 && y1 <= boardsize - 4 ) {
  345.             Addup ( x1, y1, dir, gamewon );
  346.             for ( j = 0; j <= 4; j ++ )
  347.                 UpdateValue ( row, col, x1, y1, dir, j );
  348.         }
  349.     }
  350. }
  351.